package someTestExcemple.huaweiOd.divideAndRecursion;
//华为OD机试 - BOSS的收入 - 回溯（Java 2025 A卷 100分）
//https://blog.csdn.net/guorui_java/article/details/132251826
import java.util.*;
//todo 没看懂代码
public class BossIncome {
    /**
     * 经销商收入关联集合
     *
     * key：顶级父节点
     * value：[{子节点1：收入},{子节点2：收入}]
     */
    static Map<Integer, List<Map<Integer, Integer>>> mapList = new HashMap<>();
    static int bossId;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = Integer.parseInt(sc.nextLine());

        List<Integer> sonList = new ArrayList<>();
        List<Integer> fatherList = new ArrayList<>();

        for (int i = 0; i < num; i++) {
            // id 上级id 收入
            String[] str = sc.nextLine().split(" ");
            int sonId = Integer.parseInt(str[0]);
            int fatherId = Integer.parseInt(str[1]);
            int income = Integer.parseInt(str[2]);

            sonList.add(sonId);
            fatherList.add(fatherId);

            Map<Integer, Integer> map = new HashMap<>();
            map.put(sonId, income);
            if (mapList.containsKey(fatherId)) {
                mapList.get(fatherId).add(map);
            } else {
                List<Map<Integer, Integer>> maps = new ArrayList<>();
                maps.add(map);
                mapList.put(fatherId, maps);
            }
        }
        // 根据题意，没做过子节点的父节点就是boss
        bossId = findBossId(sonList, fatherList);
        // 经销商收入关联集合
        System.out.println(mapList);
        // 获取boss的收入
        getBossMoney(bossId, bossId);
        // 输出[boss的ID，总收入]
        System.out.println(bossId+" "+bossSum);
    }

    /**
     * 根据题意，没做过子节点的父节点就是boss
     * @param sonList 子节点集合
     * @param fatherList 父节点集合
     * @return 顶级父节点boss
     */
    public static Integer findBossId(List<Integer> sonList, List<Integer> fatherList) {
        for (Integer pId : fatherList) {
            if(!sonList.contains(pId)){
                return pId;
            }
        }
        return null;
    }

    // 找出某个子节点的子经销商的提成
    static Integer bossSum = 0;

    /**
     * 递归获取boss的收入
     * @param id 当前经销商
     * @param fatherId 上一级经销商
     * @return
     */
    public static Integer getBossMoney(int id, int fatherId) {
        // 如果不是boss经销商
        if (id != bossId) {
            int money = 0;
            // 计算上一级经销商的钱
            if (mapList.containsKey(fatherId)) {
                // 获取上一级经销商的下级经销商的钱
                for (Map<Integer, Integer> map : mapList.get(fatherId)) {
                    // 获取下级经销商的钱
                    if(map.containsKey(id)){
                        money = map.get(id);
                        break;
                    }
                }
            }
            // 如果子经销商还有子经销商，则要将其的利润加到上一级经销商
            if (mapList.containsKey(id)) {
                for (Map<Integer, Integer> map : mapList.get(id)) {
                    money += getBossMoney(map.keySet().iterator().next(), id);
                }
            }
            // 满100提15
            return (money / 100) * 15;
        } else {
            // 如果是最终boss经销商，直接计算总money
            for (Map<Integer, Integer> map : mapList.get(bossId)) {
                int next = map.keySet().iterator().next();
                bossSum += getBossMoney(next, bossId);
            }
        }
        return 0;
    }
}
